package com.cmos.um.service.impl;

import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.cmos.csf.api.client.extend.CsfResponse;
import com.cmos.csf.client.service.api.CsfServiceCaller;
import com.cmos.um.beans.CtiMessage;
import com.cmos.um.beans.CtiMessageExtends;
import com.cmos.um.beans.CtiMessageTask;
import com.cmos.um.iservice.ICtiMessageSV;
import com.cmos.um.iservice.ICtiMessageTaskSV;
import com.cmos.um.iservice.ITaskSV;
import com.cmos.um.utils.*;
import com.cmos.um.utils.*;
import com.cmos.um.utils.http.RestClientHttpRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Service
public class TaskSVImpl implements ITaskSV {

    private final static Logger logger = LoggerFactory.getLogger(TaskSVImpl.class);

    @Autowired
    private ICtiMessageSV ctiMessageservice;
    @Autowired
    private ICtiMessageTaskSV ICtiMessageTaskSV;
    @Autowired
    private RestClientHttpRequest clien;

    /**
     * 【操作】新增任务信息同步
     *
     * @param params 参数集JSONObject（含params参数——此参数在输入函数时为Json字符串）
     * @return Map<String,Object> 返回的数据（Map<String,Object>形式）
     */
    @Override
    @Transactional
    public Map<String, Object> synchCampBsicInfoandStrategy(JSONObject params) {

        JSONObject toCC = new JSONObject();
        //查询所有的cti
        List<CtiMessage> ctiMessage = ctiMessageservice.queryAll();

        if (ctiMessage.isEmpty()) {
            return new RetMap(logger, "尚未建设（和注册）任何的CC平台");
        }

        //4.1 算法：寻找一个合适的CTI——目前采用平均分配的算法

        CtiMessage suit = null; // CC平台的相关数据——来自cti_message表
        suit = CtiAlgorithm.GetBastCti(ctiMessage);
        //b 记录分配的cti平台的IP地址
        String ctiIp = suit.getCtiIp();
        String ctiId = suit.getCtiId();
        JSONObject P_params = params.getJSONObject("params");
        String campaignId = P_params.getString("campaignId"); // 原始传来的任务号
        String serviceId = "000001" + WSContent.companyNo + "11" + campaignId;// CTI服务器中的任务号
        String beginTime1 = P_params.getString("beginTime1");
        String beginTime2 = P_params.getString("beginTime2");
        String beginTime3 = P_params.getString("beginTime3");
        try {
            //A CC操作：添加日程和日程条目
            if (!beginTime1.isEmpty() || !beginTime2.isEmpty() || !beginTime3.isEmpty()) {
                WSRtnJsonCtx resultSchedule = schedule(ctiIp, campaignId, WSContent._SAVE);
                if (!"0".equals(resultSchedule.getRescode())) {
                    logger.error("增加日程失败，返回的信息为：" + resultSchedule.getResJsonObj());
                    return new RetMap("0", "服务器捕获到异常");
                }
                //b 加日程条目
                //i 搜集数据
                for (int i = 1; i <= 3; i++) {
                    String beginTime = simpleSQL.m2s(P_params, "beginTime" + i);
                    String endTime = simpleSQL.m2s(P_params, "endTime" + i);
                    if (beginTime == null || beginTime.isEmpty()) {
                        continue;
                    }

                    if (endTime == null || endTime.isEmpty()) {
                        endTime = "23:59";
                    }
                    WSRtnJsonCtx resultScheduleItem = scheduleItem(campaignId, i, beginTime, endTime, ctiIp, WSContent._SAVE);
                    if (!"0".equals(resultScheduleItem.getRescode())) {
                        logger.error("增加第" + i + "条日程条目失败，返回的信息为：" + resultSchedule.getResJsonObj());
                        return new RetMap("0", "服务器捕获到异常");
                    }
                }
            } else {
                logger.error("任务日程为空");
                return new RetMap("0", "服务器捕获到异常");
            }
            //添加任务
            WSRtnJsonCtx resultTask = task(params, ctiIp, WSContent._SAVE);
            if (!"0".equals(resultTask.getRescode())) {
                logger.error("新增任务失败，返回的信息为：" + resultTask.getResJsonObj());
                return new RetMap("0", "服务器捕获到异常");
            }
        } catch (Exception e) {
            logger.error("调用httpclin失败，返回的信息为：" + e.getMessage());
            return new RetMap("0", "服务器捕获到异常");
        }
        try {
            //在cti_message_task表中记录分配的cti相关信息
            CtiMessageTask ctiMessageTask = new CtiMessageTask();
            ctiMessageTask.setTaskId(campaignId);//原始的任务id
            ctiMessageTask.setCtiId(ctiId);//分配到哪个cti
            ctiMessageTask.setTaskXfId(serviceId);//新方的任务id
            ICtiMessageTaskSV.insertSelective(ctiMessageTask);
            //更新分配到任务的cti的任务数
            CtiMessage ctimessage = new CtiMessage();
            ctimessage.setCtiId(ctiId);
            ctimessage.setTaskCount(suit.getTaskCount() + 1);
            ctiMessageservice.updateByPrimaryKeySelective(ctimessage);
        } catch (Exception e) {
            return new RetMap("0", "服务器捕获到异常");
        }
        return new RetMap("成功");
    }

    /**
     * 【操作】任务基本信息修改同步
     *
     * @param params 参数集JSONObject（含params参数——此参数在输入函数时为Json字符串）
     * @return Map<String,Object> 返回的数据（Map<String,Object>形式）
     */
    @Override
    @Transactional
    public Map<String, Object> uptCampBsicInfoandStrategy(JSONObject params) {
        JSONObject P_params = params.getJSONObject("params");
        String campaignId = P_params.getString("campaignId"); // 原始传来的任务号
        String serviceId = "000001" + WSContent.companyNo + "11" + campaignId;// XF的任务号
        String beginTime1 = P_params.getString("beginTime1");
        String beginTime2 = P_params.getString("beginTime2");
        String beginTime3 = P_params.getString("beginTime3");

        CtiMessageExtends ctiMessageExtends = ctiMessageservice.queryCtimessageBytaskId(campaignId);
        if (ctiMessageExtends == null) {
            logger.error("没有找到任务号对应的cti");
            return new RetMap("0", "没有找到任务号对应的cti");
        }
        String ctiIp = ctiMessageExtends.getCtiIp();
        try {
            //4.1 在【新方】平台修改任务信息
            if (!beginTime1.isEmpty() || !beginTime2.isEmpty() || !beginTime3.isEmpty()) {
                //b 加日程条目
                for (int i = 1; i <= 3; i++) {
                    //i 搜集数据
                    String beginTime = simpleSQL.m2s(P_params, "beginTime" + i);
                    String endTime = simpleSQL.m2s(P_params, "endTime" + i);
                    if (beginTime == null || beginTime.isEmpty()) {
                        continue;
                    }
                    if (endTime == null || endTime.isEmpty()) {
                        endTime = "23:59";
                    }
                    WSRtnJsonCtx resultScheduleItem = scheduleItem(campaignId, i, beginTime, endTime, ctiIp, WSContent._UPDATE);
                    if (!"0".equals(resultScheduleItem.getRescode())) {
                        logger.error("修改第" + i + "条日程条目失败，返回的信息为：" + resultScheduleItem.getResJsonObj());
                        return new RetMap("0", "服务器捕获到异常");
                    }
                }
            } else {
                logger.error("任务日程条目为空");
                return new RetMap("0", "服务器捕获到异常");
            }
            //修改任务
            WSRtnJsonCtx resultTask = task(params, ctiIp, WSContent._UPDATE);
            if (!"0".equals(resultTask.getRescode())) {
                logger.error("修改任务失败，返回的信息为：" + resultTask.getResJsonObj());
                return new RetMap("0", "服务器捕获到异常");
            }
        } catch (Exception e) {
            return new RetMap("0", "服务器捕获到异常");
        }
        //5 函数正s常结束，返回正常响应
        return new RetMap("任务修改成功");
    }


    /**
     * 【操作】任务状态更改通知接口
     *
     * @param params 参数集JSONObject（含params参数——此参数在输入函数时为Json字符串）
     * @return Map<String,Object> 返回的数据（Map<String,Object>形式）
     */
    @Override
    @Transactional
    public Map<String, Object> synchCampaignStates(JSONObject params) {

        JSONObject toCC = new JSONObject();//准备发给toCC的信息
        JSONObject P_params = params.getJSONObject("params");
        //3.1 循环处理Beans里的每一个要修改状态的任务
        String ctiId = null;//CTI平台编号（名称）
        String campaignId = null;// 原始传来的任务号 数据库中的taskId
        String taskXfId = null;// CTI服务器中的任务号 数据库中的taskXfId
        String ctiIp = null; // CTI服务器的IP地址
        String deleteFlag = null;//删除标示
        JSONArray P_beans = params.getJSONArray("beans");//读出请求中"beans"的JSONArray

        for (Object P_bean : P_beans) {
            JSONObject J_bean = (JSONObject) P_bean;
            campaignId = J_bean.getString("campaignId");//原始任务id
            if (campaignId.length() != 16) {
                return new RetMap("0", "任务号必须为16位");
            }
            taskXfId = "000001" + WSContent.companyNo + "11" + campaignId;//XF任务id
            CtiMessageTask ctiMessageTask = new CtiMessageTask();
            ctiMessageTask.setTaskId(campaignId);
            ctiMessageTask.setTaskXfId(taskXfId);
            CtiMessage cti = ctiMessageservice.queryCtimessageBytaskId(campaignId);//根据任务id查出要修改的cti
            if (cti == null) {
                return new RetMap("0", "没有找到任务号对应的cti");
            }
            ctiIp = cti.getCtiIp();
            deleteFlag = J_bean.getString("deleteFlag");
            //4.1 在【新方】平台修改任务状态
            if ("Y".equals(deleteFlag)) {//如果删除标识为yes则删除，否则改campaignId下的日程，日程条目，任务
                //删除日程条目
                JSONObject scheduleItem = new JSONObject();
                scheduleItem.put("scheduleKey", campaignId);
                WSRtnJsonCtx listScheduleItem = clien.doPost(WSContent.vccUrl, ctiIp, "listScheduleItem", WSContent._OTHER, scheduleItem);
                if (listScheduleItem.getOutputObj().isEmpty()) {
                    logger.error("没有查到此任务的日程条目信息,返回的信息为：" + listScheduleItem.getResJsonObj());
                    return new RetMap("0", "没有查到此任务的日程条目信息");
                }
                for (int i = 1; i <= listScheduleItem.getContextArr().size(); i++) {
                    scheduleItem.put("itemKey", campaignId + i);
                    WSRtnJsonCtx resultScheduleItem = clien.doPost(WSContent.vccUrl, ctiIp, "operateScheduleItem", WSContent._DELETE, scheduleItem);
                    if (!"0".equals(resultScheduleItem.getRescode())) {
                        logger.error("删除第" + i + "条日程失败，返回的信息为：" + resultScheduleItem.getResJsonObj());
                        return new RetMap("0", "服务器捕获到异常");
                    }
                }
                //删除日程
                JSONObject toSchedule = new JSONObject();
                toSchedule.put("scheduleKey", campaignId); // 日程键，以任务号作为日程键
                toSchedule.put("vccId", WSContent.companyNo); // 集团号

                //先查询日程
                WSRtnJsonCtx schedule = clien.doPost(WSContent.vccUrl, ctiIp, "listSchedule", WSContent._OTHER, toSchedule);//查询日程
                if (listScheduleItem.getOutputObj().isEmpty()) {
                    logger.error("没有查到此任务的日程信息,返回的信息为：" + listScheduleItem.getResJsonObj());
                    return new RetMap("0", "没有查到此任务的日程信息");
                }

                toSchedule.put("scheduleName", campaignId); // 日程名称
                String updateKey = schedule.getOutputObj().getJSONArray("contextArray").getJSONObject(0).getString("updateKey");
                toSchedule.put("updateKey", updateKey); // 更新标识

                WSRtnJsonCtx resultSchedule = clien.doPost(WSContent.vccUrl, ctiIp, "operateSchedule", WSContent._DELETE, toSchedule);

                if (!"0".equals(resultSchedule.getRescode())) {
                    logger.error("删除日程失败，返回的信息为：" + resultSchedule.getResJsonObj());
                    return new RetMap("0", "服务器捕获到异常");
                }
                //删除任务
                toCC.put("serviceId", taskXfId); // 人工外呼任务号，0000+01+6位集团号+11+4位流水号
                toCC.put("vccId", WSContent.companyNo); // 集团号，6位自然数，不能重复
                WSRtnJsonCtx resultTask = clien.doPost(WSContent.servUrl, ctiIp, "operateHumanTask", WSContent._DELETE, toCC);
                if (!"0".equals(resultTask.getRescode())) {
                    logger.error("删除任务失败，返回的信息为：" + resultTask.getResJsonObj());
                    return new RetMap("0", "服务器捕获到异常");
                }

                // 数据库操作 根据taskId删除cti_message_task 中的条目
                ctiMessageTask = new CtiMessageTask();
                ctiMessageTask.setTaskId(campaignId);
                ICtiMessageTaskSV.deleteByPrimaryKey(ctiMessageTask);
                //f 数据库操作 根据ctiId 将taskCount-1
                CtiMessage ctimessage = new CtiMessage();
                ctimessage.setCtiId(cti.getCtiId());
                ctimessage.setTaskCount(cti.getTaskCount() - 1);
                //根据ctiid修改task_count数
                ctiMessageservice.updateByPrimaryKeySelective(ctimessage);
            } else if ("N".equals(deleteFlag)) {//如果删除标识为no则，只是修改任务信息里的有效性
                String state = J_bean.getString("state");//原始数据中的状态
                String changeState ="0";//存储是effective要修改的状态
                if ("05".equals(state) || "07".equals(state)) {//01：策划；04执行中；05：暂停；06完成；07：过期  05 07 是1
                    changeState = "1";
                }
                if ("06".equals(state)){
                    changeState = "4";
                }
                Map<String, Object> retTaskInfo = null;//接收查到的任务信息
                //a CC操作 根据campaigId和Vccid查出要修改的任务条目
                //toCC.put("VccId", "100000");
                toCC.put("startItem", "0");
                toCC.put("maxItem", "1");
                toCC.put("projectId", campaignId);
                WSRtnJsonCtx resultTask = clien.doPost(WSContent.servUrl, ctiIp, "listHumanTask", WSContent._OTHER, toCC);
                if ("0".equals(resultTask.getRescode()) && resultTask.getOutputObj()==null) {
                    return new RetMap("-9999", "没有查询到此任务的相关信息！");
                }
                //b CC操作：修改任务信息里的有效性
                JSONObject taskInfo =  resultTask.getOutputObj().getJSONArray("contextArray").getJSONObject(0);
                taskInfo.put("effective", changeState);
                WSRtnJsonCtx resultUploadTask = clien.doPost(WSContent.servUrl, ctiIp, "operateHumanTask", WSContent._UPDATE, taskInfo);
                if (!"0".equals(resultUploadTask.getRescode())){
                    logger.error("调用cti修改任务信息接口失败！返回的信息为："+resultUploadTask.getResJsonObj());
                    return new RetMap("-9999", "调用cti修改任务信息接口失败！");
                }
            }
        }
        //6 函数正常结束，返回正常响应
        return new RetMap("成功");
    }

    /**
     * 【操作】任务状态修改接口（提供给cti）
     *
     * @param params 参数集JSONObject（含params参数——此参数在输入函数时为Json字符串）
     * @return Map<String , Object> 返回的数据（Map<String,Object>形式）
     */
    @Override
    public Map<String, Object> updateTaskStatus(JSONObject params) {
        //CsfResponse result = CsfServiceCaller.call("NGOC_UPDATETASKFORSTATUS_POST", params);
        CsfResponse result = CsfServiceCaller.call(WSContent.csfTaskStatus, params);

        Map<String, Object> resultCti = new LinkedHashMap<>();
        JSONObject resultCsf = JSONObject.parseObject(result.getResponse()).getJSONObject("object");
        resultCti.put("rtnCode",resultCsf.getString("rtnCode"));
        resultCti.put("rtnMsg",resultCsf.getString("rtnMsg"));
        return resultCti;
    }

    /**
     * 日程管理
     *
     * @param ctiIp
     * @param campaignId 原始任务id
     * @return
     */
    public WSRtnJsonCtx schedule(String ctiIp, String campaignId, String opr) {
        // b 记录平台的IP地址和CC名称（CCID）
        JSONObject toCC = new JSONObject();
        toCC.put("scheduleKey", campaignId); // 日程键，以任务号作为日程键
        toCC.put("vccId", WSContent.companyNo); // 集团号
        toCC.put("scheduleName", campaignId); // 日程名称
        toCC.put("updateKey", simpleSQL.cinNowTime()); // 更新标识
        WSRtnJsonCtx wsRtnJsonCtx = clien.doPost(WSContent.vccUrl, ctiIp, "operateSchedule", opr, toCC);
        return wsRtnJsonCtx;
    }

    /**
     * 日程条目管理
     *
     * @param ctiIp
     * @param campaignId 原始任务id
     * @return
     */
    public WSRtnJsonCtx scheduleItem(String campaignId, int i, String beginTime, String endTime, String ctiIp, String opr) {
        JSONObject toCC = new JSONObject();
        //i 搜集数据
        toCC.put("itemKey", campaignId + String.valueOf(i)); // 条目键
        toCC.put("scheduleKey", campaignId); // 日程键
        toCC.put("sunday", "1"); // 周日，0=无，1=有
        toCC.put("monday", "1"); // 周一，0=无，1=有
        toCC.put("tuesday", "1"); // 周二，0=无，1=有
        toCC.put("wednesday", "1"); // 周三，0=无，1=有
        toCC.put("thursday", "1"); // 周四，0=无，1=有
        toCC.put("friday", "1"); // 周五，0=无，1=有
        toCC.put("saturday", "1"); // 周六，0=无，1=有
        toCC.put("hourStart", beginTime.substring(0, 2)); // 开始小时
        toCC.put("hourEnd", endTime.substring(0, 2)); // 结束小时
        toCC.put("minuteStartminuteStart", beginTime.substring(3, 5)); // 开始分钟
        toCC.put("minuteEnd", endTime.substring(3, 5)); // 结束分钟
        toCC.put("updateKey", simpleSQL.cinNowTime()); // 更新标识
        WSRtnJsonCtx wsRtnJsonCtx = clien.doPost(WSContent.vccUrl, ctiIp, "operateScheduleItem", opr, toCC);
        return wsRtnJsonCtx;
    }

    /**
     * 任务管理
     *
     * @param params
     * @param ctiIp
     * @return
     */
    public WSRtnJsonCtx task(JSONObject params, String ctiIp, String opr) {
        // b 记录平台的IP地址和CC名称（CCID）

        JSONObject toCC = new JSONObject();
        JSONObject P_params = params.getJSONObject("params");
        String campaignId = P_params.getString("campaignId");// 华为原始消
        String serviceId = "000001" + WSContent.companyNo + "11" + campaignId;// CTI服务器中的任务号

        //a 准备建任务的参数
        toCC.put("serviceId", serviceId); // 人工外呼任务号，0000+01+6位集团号+11+4位流水号
        toCC.put("vccId", WSContent.companyNo); // 集团号，6位自然数，不能重复
        toCC.put("serviceName", simpleSQL.m2s(P_params, "campaignName")); // 服务名称
        toCC.put("introduction", ""); // 简短说明
        if ("05".equals(simpleSQL.m2s(P_params, "state")) || "07".equals(simpleSQL.m2s(P_params, "state"))) {
            toCC.put("effective", "1"); // 有效性，0=启用（可以或正在进行外呼），1=暂停，2=预处理（平台正在生成相关文件），3=预处理错误，4=任务完成，5=号码处理完成
        }
        else {
            toCC.put("effective", "0");
        }
        toCC.put("serviceStart", DataUtil.timeS2C(simpleSQL.m2s(P_params, "beginDate"))); // 服务开始时间，格式=yyyyMMddHHmmss
        toCC.put("serviceEnd", DataUtil.timeS2C(simpleSQL.m2s(P_params, "endDate"))); // 服务结束时间，格式=yyyyMMddHHmmss
        toCC.put("scheduleKey", campaignId); // 日程键，对应日程管理接口里list中ScheduleContext 的 scheduleKey，" 渐进拨号" 和" 预测拨号" 方式进行外拨，必须设置日程
        toCC.put("callNumberFile", ""); // 外呼文件路径，格式为=6位企业标识/outAddress/文件子路径
        toCC.put("serviceType", "3"); // 任务类型，默认0，0=普通，2=第三方外呼号码
        toCC.put("av", "1"); // 音视频类型，默认1=1=会议音频，2=会议视频
        toCC.put("recordType", "1"); // 录音方式，默认0，0=服务器不录，1=服务器录，4=按间隔抽样录，5=按百分比抽样录
        toCC.put("recordSample", "0"); // 录音抽样值，默认0
        toCC.put("callInLimit", "0"); // 呼入线数限制，默认0，0=不限制，1=平均每当值座席排队长度，2=限定最大呼入线数
        toCC.put("callInMax", "0"); // 呼入线数值，默认0
        toCC.put("hitRate", "100"); // 成功率，默认0=0至100的整数，预留属性暂时无用
        toCC.put("reCall", "1"); // 重呼次数，默认1，1-3次
        toCC.put("intervalTime", "0"); // 间隔时间，单位=秒，默认7200
        toCC.put("autoResponder", "0"); // 自动应答机，默认0，0=无，1=有
        toCC.put("chargeNumber", "000002" + WSContent.companyNo + P_params.getString("callerNo")); // 计费分机号码，应该为已存在分机
        toCC.put("noAnswerTime", simpleSQL.m2s(P_params, "obOverTime")); // 无人接听时间，单位=秒，默认60
        toCC.put("callType", "3"); // 外拨方式，默认3，0=预览拨号，1=精确拨号，2=渐进拨号，3=预测拨号(默认)，4= 精确预览
        toCC.put("velocityMax", "10"); // 外拨最快速率，默认20，单位=次/秒
        toCC.put("agentRate", Integer.parseInt(P_params.getString("userRate"))*10); // 外呼座席比，(外拨速率因子)为外呼线数与座席数的比例，单位是1%，取值范围50-1000，100为正常速度，大于100为加速，小于100为减速
        toCC.put("maxWait", simpleSQL.m2s(P_params, "waitTime")); // 用户等待空闲座席的最大时长，默认5，用户等待空闲座席的最大时长，单位=秒，预留字段，暂时无用
        toCC.put("initAlerting", "0"); // 初始的平均振铃时长，默认0，单位=秒
        toCC.put("initDuration", "0"); // 初始的每外呼时长，默认0，单位=秒
        toCC.put("abandonRate", "0"); // 放弃率，默认0，1至100
        toCC.put("velocityFactor", "1"); // 外拨速率因子，默认1，预留属性
        toCC.put("queueLength", "500"); // 排队长度，默认500
        toCC.put("queueWarning", "500"); // 排队告警长度，默认500
        toCC.put("queueTimeout", "5"); // 排队超时时间，默认5，单位=秒
        toCC.put("sumQueueTime", "60"); // 所有排队时间，默认60，单位=秒
        toCC.put("queueMusic", ""); // 排队音
        toCC.put("alteringMusic", ""); // 回铃音
        toCC.put("empId", "0"); // 报工号，默认0，0=无，1=有
        toCC.put("empIdMusic", ""); // 报工号音
        toCC.put("taskPriority", "0"); // 优先级，默认0
        toCC.put("agentMax", "0"); // 最大座席数，默认0
        toCC.put("authority", ""); // 权限
        toCC.put("distribute", "3"); // 分配策略，默认0，0=平均分配，1=座席优先级高，2=座席优先级低，3=当前等待时间最长的优先，4=当天累计等待时间最长的优先，5=当天平均等待时间最长的优先，6=当天应答时间最少的优先，7=当天应答次数最少的优先
        toCC.put("callBack", "0"); // 是否允许回拨任务，，默认0，0=无，1=有
        toCC.put("callBackService", ""); // 回拨任务号，callBackFlag为1时，非空
        toCC.put("callBackOrigin", ""); // 回拨任务原任务号
        toCC.put("connectAgentType", "2"); // 连接座席类型， ，默认2，1=用户振铃时去呼叫座席，2=用户接通时去呼叫座席
        toCC.put("audioMatchFlag", "0"); // 是否进行识别运营商提示音，默认1，0=不进行，1=进行
        toCC.put("amdFlag", "0"); // 是否进行amd检测，默认0，0=不进行，1=进行
        toCC.put("recordBeforeConnectFlag", "0"); // 在座席接通前是否录音，默认1，0=不录，1=需要录
        toCC.put("filterNumFlag", "0"); // 是否进行洗号标志 ，默认0，0=不进行洗号，1=洗号，预留属性，暂时无用
        toCC.put("filterCondition", ""); // 洗号规则
        toCC.put("batchName", ""); // 任务批次名称，每个任务分属于一个批次，批次内任务按优先级串行执行，批次之间的任务可并行执行
        toCC.put("filterTimes", ""); // 洗号次数，预留属性，暂时无用
        toCC.put("totalCallCount", ""); // 总呼叫次数
        toCC.put("totalFilterResult", ""); // 洗号结果，格式为01=32|02=22|.....预留属性，暂时无用
        toCC.put("autoAnswer", "0"); // 自动应答标志，默认1，0=非自动应答，1=自动应答
        toCC.put("autoWorkOn", "0"); // 自动状态标志，默认0，0=非自动空闲，1=自动空闲
        toCC.put("autoWorkSubstate", "0"); // 自动状态子状态，默认0
        toCC.put("autoWorkInterval", ""); // 自动空闲/示忙间隔时间，默认0
        toCC.put("allowQuitIdle", "0"); // 是否允许从空闲状态退出，默认1，0=允许从空闲状态退出，1=禁止从空闲状态退出
        toCC.put("holdMusic", ""); // hold时播放的提示音
        toCC.put("afterCallService", "000001111111003001"); // 坐席挂机转服务 ，如果为空则结束用户通话，不为空则排队该服务，目前只支持ivr服务
        toCC.put("afterCallServiceSec", ""); // 坐席挂机转服务最小通话时长 ， ，默认0，坐席应答多少秒后，挂机才转服务,默认0，只要应答挂机就转服务
        toCC.put("projectId", campaignId); // 项目标识（编号）
        toCC.put("projectName", simpleSQL.m2s(P_params, "campaignName")); // 项目名称
        toCC.put("projectType", ""); // 项目类别
        toCC.put("updateKey", simpleSQL.cinNowTime()); // 更新标识
        WSRtnJsonCtx wsRtnJsonCtx = clien.doPost(WSContent.servUrl, ctiIp, "operateHumanTask", opr, toCC);
        return wsRtnJsonCtx;
    }
}
